home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / scope / 101-125 / scopedisk102 / hamsharp / hamsharp2.c < prev    next >
C/C++ Source or Header  |  1995-03-19  |  5KB  |  236 lines
  1. /*
  2. ** Part 2
  3. */
  4.  
  5. #include <stdio.h>
  6. #include <functions.h>
  7. #include <exec/exec.h>
  8. #include <libraries/dos.h>
  9.  
  10. extern void *malloc (), *calloc ();
  11. extern char gifname [], iffname [];
  12. extern int update;
  13.  
  14. /* ADT for list */
  15. struct listentry {
  16.    struct listentry *next;
  17.    char *gifname, *iffname;
  18. };
  19.  
  20. struct listentry *list = NULL;
  21.  
  22. /* Initalize list */
  23. initlist ()
  24. {
  25.    list = NULL;
  26. }
  27.  
  28. /* Add entry to list. Process update flag */
  29. addlist (gifname, iffname)
  30. char *gifname, *iffname;
  31. {
  32.    struct listentry *new;
  33.  
  34.    if (update) {
  35.       if (existsfile (iffname))
  36.          return;
  37.    }
  38.  
  39.    new = malloc (sizeof (struct listentry));
  40.    if (!new)
  41.       fatalerr ("Out of memory");
  42.    new->next = list;
  43.    new->gifname = calloc (strlen (gifname) + 1, sizeof (char));
  44.    if (!new->gifname)
  45.       fatalerr ("Out of memory");
  46.    new->iffname = calloc (strlen (iffname) + 1, sizeof (char));
  47.    if (!new->iffname)
  48.       fatalerr ("Out of memory");
  49.    strcpy (new->gifname, gifname);
  50.    strcpy (new->iffname, iffname);
  51.    list = new;
  52. }
  53.  
  54. /* Get and delete entry from list. Returns 0 if no more */
  55. getlist (gifname, iffname)
  56. char *gifname, *iffname;
  57. {
  58.    struct listentry *old = list;
  59.  
  60.    if (list == NULL)
  61.       return (0);
  62.    strcpy (gifname, list->gifname);
  63.    strcpy (iffname, list->iffname);
  64.    list = list->next;
  65.    free (old->gifname);
  66.    free (old->iffname);
  67.    free (old);
  68.    return (-1);
  69. }
  70.  
  71. /* Free memory occupied by list */
  72. freelist ()
  73. {
  74.    while (getlist (gifname, iffname));
  75. }
  76.  
  77. /* Check if given file exists */
  78. existsfile (filename)
  79. char *filename;
  80. {
  81.    struct Lock *lock;
  82.  
  83.    lock = Lock (filename, ACCESS_READ);
  84.    if (!lock)
  85.       return (0);
  86.    UnLock (lock);
  87.    return (-1);
  88. }
  89.  
  90. /* Add files matching template in gifname [] to list */
  91. getwild ()
  92. {
  93.    struct Lock *lock;
  94.    struct FileInfoBlock *fib;
  95.    int success, i;
  96.    long ioerr;
  97.    char dirname [120], template [120];
  98.  
  99.    for (i = 0; i < strlen (gifname); i++)
  100.       if (gifname [i] == '*')
  101.          goto wild;
  102.    addlist (gifname, iffname);   /* No wildcards */
  103.    return;
  104.  
  105. wild:
  106.    dirname [0] = '\0';
  107.    strcpy (template, gifname);
  108.    for (i = strlen (gifname) - 1; i >= 0; i--)
  109.       if ((gifname [i] == ':') || (gifname [i] == '/')) {
  110.          strncpy (dirname, gifname, i+1);
  111.          dirname [i+1] = '\0';
  112.          strcpy (template, &gifname [i+1]);
  113.          break;
  114.       }
  115.    lock = Lock (dirname, ACCESS_READ);
  116.    if (!lock)
  117.       fatalerr ("Lock failed");
  118.    fib = AllocMem ((long) sizeof (struct FileInfoBlock), 0L);
  119.    if (!fib) {
  120.       UnLock (lock);
  121.       fatalerr ("Out of memory");
  122.    }
  123.    success = Examine (lock, fib);
  124.    if (!success) {
  125.       FreeMem (fib, (long) sizeof (struct FileInfoBlock));
  126.       UnLock (lock);
  127.       fatalerr ("Can't examine directory");
  128.    }
  129.    if (fib->fib_DirEntryType < 0) {
  130.       FreeMem (fib, (long) sizeof (struct FileInfoBlock));
  131.       UnLock (lock);
  132.       fatalerr ("Not a directory");
  133.    }
  134.    while (success = ExNext (lock, fib)) {
  135.       if (fib->fib_DirEntryType < 0)
  136.          fillwild (dirname, fib->fib_FileName, template, iffname);
  137.    }
  138.    ioerr = IoErr ();
  139.    FreeMem (fib, (long) sizeof (struct FileInfoBlock));
  140.    UnLock (lock);
  141.    if (ioerr != ERROR_NO_MORE_ENTRIES)
  142.       fatalerr ("Unexpected error while reading directory");
  143. }
  144.  
  145. /* Match and fill in wildcards and add to list */
  146. fillwild (dirname, input, gifname, iffname)
  147. char *dirname, *input, *gifname, *iffname;
  148. {
  149.    char tos (), pop ();
  150.    char gifname2 [120], iffname2 [120];
  151.    int i, j;
  152.  
  153.    initstack ();
  154.    if (match (input, gifname)) {
  155.       j = 0;
  156.       for (i = 0; i < strlen (iffname); i++) {
  157.          if ((iffname [i] == '*') && (!emptystack ())) {
  158.             while (tos () != 0)
  159.                iffname2 [j++] = pop ();
  160.             pop ();
  161.          }
  162.          else
  163.             iffname2 [j++] = iffname [i];
  164.       }
  165.       iffname2 [j] = '\0';
  166.       strcpy (gifname2, dirname);
  167.       strcat (gifname2, input);
  168.       addlist (gifname2, iffname2);
  169.    }
  170. }
  171.  
  172. match (input, template)
  173. char *input, *template;
  174. {
  175.    int success;
  176.    char temp = *template;
  177.    char inp = *input;
  178.  
  179.    switch (temp) {
  180.    case '\0' :
  181.       return (inp == '\0');
  182.    case '*' :
  183.       success = match (input, template + 1);
  184.       if (success)
  185.          push (0);
  186.       else {
  187.          if (inp == '\0')
  188.             success = (*(template + 1) == '\0');
  189.          else {
  190.             success = match (input + 1, template);
  191.             if (success)
  192.                push (inp);
  193.          }
  194.       }
  195.       return (success);
  196.    default:
  197.       if (inp == '\0')
  198.          return (temp == '\0');
  199.       if (inp != temp)
  200.          return (0);
  201.       return (match (input + 1, template + 1));
  202.    }
  203. }
  204.  
  205. char stack [256];
  206. int sp = 0;
  207.  
  208. initstack ()
  209. {
  210.    for (sp = 0; sp < 256; sp++)
  211.       stack [sp] = 0;
  212.    sp = 0;
  213. }
  214.  
  215. push (ch)
  216. char ch;
  217. {
  218.    stack [sp++] = ch;
  219. }
  220.  
  221. char pop ()
  222. {
  223.    return (stack [--sp]);
  224. }
  225.  
  226. char tos ()
  227. {
  228.    return (stack [sp-1]);
  229. }
  230.  
  231. emptystack ()
  232. {
  233.    return (sp == 0);
  234. }
  235.  
  236.